home *** CD-ROM | disk | FTP | other *** search
/ OpenGL Superbible (2nd Edition) / OpenGL SuperBible e2.iso / tools / GLUT-3.7 / PROGS / DEMOS / WALKER / walkviewer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-12  |  12.9 KB  |  494 lines
  1. /*
  2.  * walkviewer.c [from agviewer.c  (version 1.0)]
  3.  *
  4.  * AGV: a glut viewer. Routines for viewing a 3d scene w/ glut
  5.  *
  6.  * See agv_example.c and agviewer.h comments within for more info.
  7.  *
  8.  * I welcome any feedback or improved versions!
  9.  *
  10.  * Philip Winston - 4/11/95
  11.  * pwinston@hmc.edu
  12.  * http://www.cs.hmc.edu/people/pwinston
  13.  */
  14.  
  15. #include <GL/glut.h>
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <math.h>
  19.  
  20. #include "walkviewer.h"
  21.  
  22. /***************************************************************/
  23. /************************** SETTINGS ***************************/
  24. /***************************************************************/
  25.  
  26.    /* Initial polar movement settings */
  27. #define INIT_POLAR_AZ  0.0
  28. #define INIT_POLAR_EL 30.0
  29. #define INIT_DIST      3.0
  30. #define INIT_AZ_SPIN   0.5
  31. #define INIT_EL_SPIN   0.0
  32.  
  33.   /* Initial flying movement settings */
  34. #define INIT_EX        0.0
  35. #define INIT_EY       -2.0
  36. #define INIT_EZ       -2.0
  37. #define INIT_MOVE     0.01
  38. #define MINMOVE      0.001    
  39.  
  40.   /* Start in this mode */
  41. #define INIT_MODE   POLAR   
  42.  
  43.   /* Controls:  */
  44.  
  45.   /* map 0-9 to an EyeMove value when number key is hit in FLYING mode */
  46. #define SPEEDFUNCTION(x) ((x)*(x)*0.001)  
  47.  
  48.   /* Multiply EyeMove by (1+-MOVEFRACTION) when +/- hit in FLYING mode */
  49. #define MOVEFRACTION 0.25   
  50.  
  51.   /* What to multiply number of pixels mouse moved by to get rotation amount */
  52. #define EL_SENS   0.5
  53. #define AZ_SENS   0.5
  54.  
  55.   /* What to multiply number of pixels mouse moved by for movement amounts */
  56. #define DIST_SENS 0.01
  57. #define E_SENS    0.01
  58.  
  59.   /* Minimum spin to allow in polar (lower forced to zero) */
  60. #define MIN_AZSPIN 0.1
  61. #define MIN_ELSPIN 0.1
  62.  
  63.   /* Factors used in computing dAz and dEl (which determine AzSpin, ElSpin) */
  64. #define SLOW_DAZ 0.90
  65. #define SLOW_DEL 0.90
  66. #define PREV_DAZ 0.80
  67. #define PREV_DEL 0.80
  68. #define CUR_DAZ  0.20
  69. #define CUR_DEL  0.20
  70.  
  71. /***************************************************************/
  72. /************************** GLOBALS ****************************/
  73. /***************************************************************/
  74.  
  75. int     MoveMode = INIT_MODE;  /* FLYING or POLAR mode? */
  76.  
  77. GLfloat Ex = INIT_EX,             /* flying parameters */
  78.         Ey = INIT_EY,
  79.         Ez = INIT_EZ,
  80.         EyeMove = INIT_MOVE,     
  81.  
  82.         EyeDist = INIT_DIST,      /* polar params */
  83.         AzSpin  = INIT_AZ_SPIN,
  84.         ElSpin  = INIT_EL_SPIN,
  85.  
  86.         EyeAz = INIT_POLAR_AZ,    /* used by both */
  87.         EyeEl = INIT_POLAR_EL;
  88.  
  89. int agvMoving;    /* Currently moving?  */
  90.  
  91. int downx, downy,   /* for tracking mouse position */
  92.     lastx, lasty,
  93.     downb = -1;     /* and button status */
  94.                         
  95. GLfloat downDist, downEl, downAz, /* for saving state of things */
  96.         downEx, downEy, downEz,   /* when button is pressed */
  97.         downEyeMove;                
  98.  
  99. GLfloat dAz, dEl, lastAz, lastEl;  /* to calculate spinning w/ polar motion */
  100. int     AdjustingAzEl = 0;
  101.  
  102. int AllowIdle, RedisplayWindow; 
  103.    /* If AllowIdle is 1 it means AGV will install its own idle which
  104.     * will update the viewpoint as needed and send glutPostRedisplay() to the
  105.     * window RedisplayWindow which was set in agvInit().  AllowIdle of 0
  106.     * means AGV won't install an idle funciton, and something like
  107.     * "if (agvMoving) agvMove()" should exist at the end of the running
  108.     * idle function.
  109.     */
  110.  
  111. /* Some <math.h> files do not define M_PI... */
  112. #ifndef M_PI
  113. #define M_PI            3.14159265358979323846
  114. #endif
  115. #define MAX(x,y) (((x) > (y)) ? (x) : (y))
  116. #define TORAD(x) ((M_PI/180.0)*(x))
  117. #define TODEG(x) ((180.0/M_PI)*(x))
  118.  
  119. /***************************************************************/
  120. /************************ PROTOTYPES ***************************/
  121. /***************************************************************/
  122.  
  123.   /*
  124.    * these are functions meant for internal use only
  125.    * the other prototypes are in agviewer.h
  126.    */
  127.  
  128. void PolarLookFrom(GLfloat dist, GLfloat elevation, GLfloat azimuth);
  129. void FlyLookFrom(GLfloat x, GLfloat y, GLfloat z, GLfloat az, GLfloat el);
  130. int  ConstrainEl(void);
  131. void MoveOn(int v);
  132. void SetMove(float newmove);
  133. void normalize(GLfloat v[3]);
  134. void ncrossprod(float v1[3], float v2[3], float cp[3]);
  135.  
  136.  
  137. /***************************************************************/
  138. /************************ agvInit ******************************/
  139. /***************************************************************/
  140.  
  141. void agvInit(int window)
  142. {
  143.   glutMouseFunc(agvHandleButton);
  144.   glutMotionFunc(agvHandleMotion);
  145.   glutKeyboardFunc(agvHandleKeys);
  146.   RedisplayWindow = glutGetWindow();
  147.   agvSetAllowIdle(window);
  148. }
  149.  
  150. /***************************************************************/
  151. /************************ VIEWPOINT STUFF **********************/
  152. /***************************************************************/
  153.  
  154.   /*
  155.    * viewing transformation modified from page 90 of red book
  156.    */
  157. void PolarLookFrom(GLfloat dist, GLfloat elevation, GLfloat azimuth)
  158. {
  159.   glTranslatef(0, 0, -dist);
  160.   glRotatef(elevation, 1, 0, 0);
  161.   glRotatef(azimuth, 0, 1, 0);
  162.  
  163. }
  164.  
  165.   /*
  166.    * I took the idea of tracking eye position in absolute
  167.    * coords and direction looking in Polar form from denis
  168.    */
  169. void FlyLookFrom(GLfloat x, GLfloat y, GLfloat z, GLfloat az, GLfloat el)
  170. {
  171.   float lookat[3], perp[3], up[3];
  172.  
  173.   lookat[0] = sin(TORAD(az))*cos(TORAD(el));
  174.   lookat[1] = sin(TORAD(el));
  175.   lookat[2] = -cos(TORAD(az))*cos(TORAD(el));
  176.   normalize(lookat);
  177.   perp[0] = lookat[2];
  178.   perp[1] = 0;
  179.   perp[2] = -lookat[0];
  180.   normalize(perp);
  181.   ncrossprod(lookat, perp, up);
  182.   gluLookAt(x, y, z,
  183.             x+lookat[0], y+lookat[1], z+lookat[2],
  184.             up[0], up[1], up[2]);
  185. }
  186.  
  187.   /*
  188.    * Call viewing transformation based on movement mode
  189.    */
  190. void agvViewTransform(void)
  191. { 
  192.   switch (MoveMode) {
  193.     case FLYING:
  194.       FlyLookFrom(Ex, Ey, Ez, EyeAz, EyeEl);
  195.       break;
  196.     case POLAR:
  197.       PolarLookFrom(EyeDist, EyeEl, EyeAz);
  198.       break;
  199.     }
  200. }
  201.  
  202.   /*
  203.    * keep them vertical; I think this makes a lot of things easier, 
  204.    * but maybe it wouldn't be too hard to adapt things to let you go
  205.    * upside down
  206.    */
  207. int ConstrainEl(void)
  208. {
  209.   if (EyeEl <= -90) {
  210.     EyeEl = -89.99;
  211.     return 1;
  212.   } else if (EyeEl >= 90) {
  213.     EyeEl = 89.99;
  214.     return 1;
  215.   }
  216.   return 0;
  217. }
  218.  
  219.  /*
  220.   * Idle Function - moves eyeposition
  221.   */
  222. void agvMove(void)
  223. {
  224.  
  225.   switch (MoveMode)  {
  226.     case FLYING:
  227.       Ex += EyeMove*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  228.       Ey += EyeMove*sin(TORAD(EyeEl));
  229.       Ez -= EyeMove*cos(TORAD(EyeAz))*cos(TORAD(EyeEl));
  230.       break;
  231.  
  232.     case POLAR:
  233.       EyeEl += ElSpin;
  234.       EyeAz += AzSpin;
  235.       if (ConstrainEl()) {  /* weird spin thing to make things look     */
  236.         ElSpin = -ElSpin;      /* look better when you are kept from going */
  237.                                /* upside down while spinning - Isn't great */
  238.         if (fabs(ElSpin) > fabs(AzSpin))
  239.           AzSpin = fabs(ElSpin) * ((AzSpin > 0) ? 1 : -1);
  240.       }
  241.       break;
  242.     }
  243.  
  244.   if (AdjustingAzEl) {
  245.     dAz *= SLOW_DAZ;
  246.     dEl *= SLOW_DEL;
  247.   }
  248.  
  249.   if (AllowIdle) {
  250.     glutPostWindowRedisplay(RedisplayWindow);
  251.   }
  252. }
  253.  
  254.  
  255.   /*
  256.    * Don't install agvMove as idle unless we will be updating the view
  257.    * and we've been given a RedisplayWindow
  258.    */
  259. void MoveOn(int v)
  260. {
  261.   if (v && ((MoveMode == FLYING && EyeMove != 0) ||
  262.              (MoveMode == POLAR &&
  263.              (AzSpin != 0 || ElSpin != 0 || AdjustingAzEl)))) {
  264.     agvMoving = 1;
  265.     if (AllowIdle)
  266.       glutIdleFunc(agvMove);
  267.   } else {
  268.     agvMoving = 0;
  269.     if (AllowIdle)
  270.       glutIdleFunc(NULL);
  271.   }
  272. }
  273.  
  274.   /*
  275.    * set new redisplay window.  If <= 0 it means we are not to install
  276.    * an idle function and will rely on whoever does install one to 
  277.    * put statement like "if (agvMoving) agvMove();" at end of it
  278.    */
  279. void agvSetAllowIdle(int allowidle)
  280. {
  281.   if ((AllowIdle = allowidle))
  282.     MoveOn(1);
  283. }
  284.  
  285.  
  286.   /*
  287.    * when moving to flying we stay in the same spot, moving to polar we
  288.    * reset since we have to be looking at the origin (though a pivot from
  289.    * current position to look at origin might be cooler)
  290.    */
  291. void agvSwitchMoveMode(int move)
  292. {
  293.   switch (move) {
  294.     case FLYING:
  295.       Ex    = -EyeDist*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  296.       Ey    =  EyeDist*sin(TORAD(EyeEl));
  297.       Ez    =  EyeDist*(cos(TORAD(EyeAz))*cos(TORAD(EyeEl)));
  298.       EyeAz =  EyeAz;
  299.       EyeEl = -EyeEl;
  300.       EyeMove = INIT_MOVE;
  301.       break;
  302.     case POLAR:
  303.       EyeDist = INIT_DIST;
  304.       EyeAz   = INIT_POLAR_AZ;
  305.       EyeEl   = INIT_POLAR_EL;
  306.       AzSpin  = INIT_AZ_SPIN;
  307.       ElSpin  = INIT_EL_SPIN;
  308.       break;
  309.     }
  310.   MoveMode = move;
  311.   MoveOn(1);
  312.   glutPostRedisplay();
  313. }
  314.  
  315. /***************************************************************/
  316. /*******************    MOUSE HANDLING   ***********************/
  317. /***************************************************************/
  318.  
  319. void agvHandleButton(int button, int state, int x, int y)
  320. {
  321.  if (state == GLUT_DOWN && downb == -1) {  
  322.     lastx = downx = x;
  323.     lasty = downy = y;
  324.     downb = button;    
  325.  
  326.     switch (button) {
  327.       case GLUT_LEFT_BUTTON:
  328.         lastEl = downEl = EyeEl;
  329.         lastAz = downAz = EyeAz;
  330.         AzSpin = ElSpin = dAz = dEl = 0;
  331.         AdjustingAzEl = 1;
  332.     MoveOn(1);
  333.         break;
  334.  
  335.       case GLUT_MIDDLE_BUTTON:
  336.         downDist = EyeDist;
  337.     downEx = Ex;
  338.     downEy = Ey;
  339.     downEz = Ez;
  340.     downEyeMove = EyeMove;
  341.     EyeMove = 0;
  342.     }
  343.  
  344.   } else if (state == GLUT_UP && button == downb) {
  345.  
  346.     downb = -1;
  347.  
  348.     switch (button) {
  349.       case GLUT_LEFT_BUTTON:
  350.         if (MoveMode != FLYING) {
  351.       AzSpin =  -dAz;
  352.       if (AzSpin < MIN_AZSPIN && AzSpin > -MIN_AZSPIN)
  353.         AzSpin = 0;    
  354.       ElSpin = -dEl;
  355.       if (ElSpin < MIN_ELSPIN && ElSpin > -MIN_ELSPIN)
  356.         ElSpin = 0; 
  357.     }
  358.         AdjustingAzEl = 0;
  359.         MoveOn(1);
  360.     break;
  361.  
  362.       case GLUT_MIDDLE_BUTTON:
  363.     EyeMove = downEyeMove;
  364.       }
  365.   }
  366. }
  367.  
  368.  /*
  369.   * change EyeEl and EyeAz and position when mouse is moved w/ button down
  370.   */
  371. void agvHandleMotion(int x, int y)
  372. {
  373.   int deltax = x - downx, deltay = y - downy;
  374.  
  375.   switch (downb) {
  376.     case GLUT_LEFT_BUTTON:
  377.       EyeEl  = downEl + EL_SENS * ((MoveMode == FLYING) ? -deltay : deltay);
  378.       ConstrainEl();
  379.       EyeAz  = downAz + AZ_SENS * deltax;
  380.       dAz    = PREV_DAZ*dAz + CUR_DAZ*(lastAz - EyeAz);
  381.       dEl    = PREV_DEL*dEl + CUR_DEL*(lastEl - EyeEl);
  382.       lastAz = EyeAz;
  383.       lastEl = EyeEl;
  384.       break;
  385.     case GLUT_MIDDLE_BUTTON:
  386.         EyeDist = downDist + DIST_SENS*deltay;
  387.         Ex = downEx - E_SENS*deltay*sin(TORAD(EyeAz))*cos(TORAD(EyeEl));
  388.         Ey = downEy - E_SENS*deltay*sin(TORAD(EyeEl));
  389.         Ez = downEz + E_SENS*deltay*cos(TORAD(EyeAz))*cos(TORAD(EyeEl));
  390.       break;
  391.   }
  392.   glutPostRedisplay();
  393. }
  394.  
  395. /***************************************************************/
  396. /********************* KEYBOARD HANDLING ***********************/
  397. /***************************************************************/
  398.  
  399.   /*
  400.    * set EyeMove (current speed) for FLYING mode
  401.    */
  402. void SetMove(float newmove)
  403. {
  404.   if (newmove > MINMOVE) {
  405.     EyeMove = newmove;
  406.     MoveOn(1);
  407.   } else {
  408.     EyeMove = 0;
  409.     MoveOn(0);
  410.   }
  411. }
  412.  
  413.   /*
  414.    * 0->9 set speed, +/- adjust current speed  -- in FLYING mode
  415.    */
  416. /* ARGSUSED1 */
  417. void agvHandleKeys(unsigned char key, int x, int y)
  418. {
  419.   if (MoveMode != FLYING)
  420.     return;
  421.  
  422.   if (key >= '0' && key <= '9')
  423.     SetMove(SPEEDFUNCTION((key-'0')));
  424.   else
  425.     switch(key) {
  426.       case '+':  
  427.         if (EyeMove == 0)
  428.           SetMove(MINMOVE);
  429.          else
  430.       SetMove(EyeMove *= (1 + MOVEFRACTION));
  431.         break;
  432.       case '-':
  433.     SetMove(EyeMove *= (1 - MOVEFRACTION));
  434.         break;
  435.     }
  436. }
  437.  
  438. /***************************************************************/
  439. /*********************** VECTOR STUFF **************************/
  440. /***************************************************************/
  441.  
  442.   /* normalizes v */
  443. void normalize(GLfloat v[3])
  444. {
  445.   GLfloat d = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
  446.  
  447.   if (d == 0)
  448.     fprintf(stderr, "Zero length vector in normalize\n");
  449.   else
  450.     v[0] /= d; v[1] /= d; v[2] /= d;
  451. }
  452.  
  453.   /* calculates a normalized crossproduct to v1, v2 */
  454. void ncrossprod(float v1[3], float v2[3], float cp[3])
  455. {
  456.   cp[0] = v1[1]*v2[2] - v1[2]*v2[1];
  457.   cp[1] = v1[2]*v2[0] - v1[0]*v2[2];
  458.   cp[2] = v1[0]*v2[1] - v1[1]*v2[0];
  459.   normalize(cp);
  460. }
  461.  
  462. /***************************************************************/
  463. /**************************** AXES *****************************/
  464. /***************************************************************/
  465.  
  466.  
  467.   /* draw axes -- was helpful to debug/design things */
  468. void agvMakeAxesList(int displaylistnum)
  469. {
  470.   int i,j;
  471.   GLfloat axes_ambuse[] =   { 0.5, 0.0, 0.0, 1.0 };
  472.   glNewList(displaylistnum, GL_COMPILE);
  473.   glPushAttrib(GL_LIGHTING_BIT);
  474.     glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, axes_ambuse);
  475.     glBegin(GL_LINES);
  476.       glVertex3f(15, 0, 0); glVertex3f(-15, 0, 0);
  477.       glVertex3f(0, 15, 0); glVertex3f(0, -15, 0);
  478.       glVertex3f(0, 0, 15); glVertex3f(0, 0, -15);
  479.     glEnd();
  480.     for (i = 0; i < 3; i++) {
  481.       glPushMatrix();
  482.         glTranslatef(-10*(i==0), -10*(i==1), -10*(i==2));
  483.         for (j = 0; j < 21; j++) {
  484.           glutSolidCube(0.1);
  485.           glTranslatef(i==0, i==1, i==2);
  486.     }
  487.       glPopMatrix();
  488.     }
  489.   glPopAttrib();
  490.   glEndList();  
  491. }
  492.  
  493.  
  494.